﻿using System;
using System.IO;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Serialization;
using DBConnect;

namespace TISS_Add_in
{
    public static class SolicitacaoProcedimentos
    {

        #region Métodos de Conversão

        private static docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado objToProcedimento(object obj)
        {
            docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado proc = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado();
            proc = (docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)obj;
            return proc;
        }

        private static docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada objToOPM(object obj)
        {
            docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada opm = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada();
            opm = (docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)obj;
            return opm;
        }

        #endregion

        private static object geraGuiaSolicitacaoProcedimento(string filePath, string oldNodeRoot,
                                                        string newNodeRoot, TipoGuia tipoGuia)
        {
            object guia = null;

            Stream str = XMLUtils.GetCustomXmlPart(filePath, oldNodeRoot);
            XmlSerializer xs;
            switch (tipoGuia)
            {
                case TipoGuia.Solicitação_Internação:
                    xs = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ct_guiaSolicInternacao), XMLUtils.ElementRootWithANSnamespace(newNodeRoot));
                    guia = (docTissSolicitacaoProcedimento.ct_guiaSolicInternacao)xs.Deserialize(str);
                    break;
                case TipoGuia.Solicitação_Prorrogação:
                    xs = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao), XMLUtils.ElementRootWithANSnamespace(newNodeRoot));
                    guia = (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao)xs.Deserialize(str);
                    break;
                case TipoGuia.Solicitação_SADT:
                    xs = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT), XMLUtils.ElementRootWithANSnamespace(newNodeRoot));
                    guia = (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT)xs.Deserialize(str);
                    break;
                case TipoGuia.Solicitação_Odontologia:

                    break;
            }

            str.Position = 0;

            return guia;
        }

        public static docTissSolicitacaoProcedimento.ct_guiaSolicInternacao geraEnviaGuiaSolicInternacao(ref GuiaSolicitacaoProcedimento classGuiaSolicProc)
        {
            if (classGuiaSolicProc.CountGuias > 0)
            {
                docTissSolicitacaoProcedimento.ct_guiaSolicInternacao gSolicInternacao =
                        new TISS_Add_in.docTissSolicitacaoProcedimento.ct_guiaSolicInternacao();

                foreach (GuiaPath guiaPrincipalPath in classGuiaSolicProc.GuiaPaths)
                {
                    if (!guiaPrincipalPath.IsExtensao)
                    {
                        gSolicInternacao = (docTissSolicitacaoProcedimento.ct_guiaSolicInternacao)geraGuiaSolicitacaoProcedimento(guiaPrincipalPath.FilePath, "guiaSolicInternacao", "guiaSolicInternacao", classGuiaSolicProc.TipoSolicitacao);
                        if (gSolicInternacao.procedimentosExamesSolicitados != null)
                        {
                            foreach (object solicProc in gSolicInternacao.procedimentosExamesSolicitados)
                            {
                                Procedimento procedimento = new Procedimento(solicProc, guiaPrincipalPath.Indice, false,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)solicProc).procedimento);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        if (gSolicInternacao.OPMsSolicitadas != null)
                        {
                            foreach (object solicOPM in gSolicInternacao.OPMsSolicitadas)
                            {
                                Procedimento procedimento = new Procedimento(solicOPM, guiaPrincipalPath.Indice, true,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)solicOPM).OPM);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        break;
                    }
                }

                foreach (GuiaPath guiaExtPath in classGuiaSolicProc.GuiaPaths)
                {
                    if (guiaExtPath.IsExtensao)
                    {
                        docTissSolicitacaoProcedimento.ct_guiaSolicInternacao gExtSolicInternacao =
                            new TISS_Add_in.docTissSolicitacaoProcedimento.ct_guiaSolicInternacao();
                        gExtSolicInternacao = (docTissSolicitacaoProcedimento.ct_guiaSolicInternacao)geraGuiaSolicitacaoProcedimento(guiaExtPath.FilePath, "guiaSolicInternacao", "guiaSolicInternacao", classGuiaSolicProc.TipoSolicitacao);

                        if (gExtSolicInternacao.procedimentosExamesSolicitados != null)
                        {
                            foreach (object solicProcExt in gExtSolicInternacao.procedimentosExamesSolicitados)
                            {
                                Procedimento procedimento = new Procedimento(solicProcExt, guiaExtPath.Indice, false,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)solicProcExt).procedimento);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        if (gExtSolicInternacao.OPMsSolicitadas != null)
                        {
                            foreach (object solicOPMExt in gExtSolicInternacao.OPMsSolicitadas)
                            {
                                Procedimento procedimento = new Procedimento(solicOPMExt, guiaExtPath.Indice, true,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)solicOPMExt).OPM);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                    }
                }
                gSolicInternacao.procedimentosExamesSolicitados = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado[classGuiaSolicProc.CountProcedimentos];
                gSolicInternacao.procedimentosExamesSolicitados = classGuiaSolicProc.ProcedimentoToArray().ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado>(objToProcedimento)).ToArray();
                gSolicInternacao.OPMsSolicitadas = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada[classGuiaSolicProc.CountOPMs];
                gSolicInternacao.OPMsSolicitadas = classGuiaSolicProc.OPMToArray().ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada>(objToOPM)).ToArray();
                classGuiaSolicProc.GuiaSolicProc = gSolicInternacao;
                return gSolicInternacao;
            }
            return null;
        }

        public static docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao geraEnviaGuiaProrrogacao(ref GuiaSolicitacaoProcedimento classGuiaSolicProc)
        {
            if (classGuiaSolicProc.CountGuias > 0)
            {
                docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao gSolicProrrogacao =
                        new TISS_Add_in.docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao();

                foreach (GuiaPath guiaPrincipalPath in classGuiaSolicProc.GuiaPaths)
                {
                    if (!guiaPrincipalPath.IsExtensao)
                    {
                        gSolicProrrogacao = (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao)geraGuiaSolicitacaoProcedimento(guiaPrincipalPath.FilePath, "guiaSolicitacaoProrrogacao", "guiaSolicitacaoProrrogacao", classGuiaSolicProc.TipoSolicitacao);
                        if (gSolicProrrogacao.procedimentosExamesSolicitados != null)
                        {
                            foreach (object solicProc in gSolicProrrogacao.procedimentosExamesSolicitados)
                            {
                                Procedimento procedimento = new Procedimento(solicProc, guiaPrincipalPath.Indice, false,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)solicProc).procedimento);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        if (gSolicProrrogacao.OPMsSolicitadas != null)
                        {
                            foreach (object solicOPM in gSolicProrrogacao.OPMsSolicitadas)
                            {
                                Procedimento procedimento = new Procedimento(solicOPM, guiaPrincipalPath.Indice, true,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)solicOPM).OPM);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        break;
                    }
                }

                foreach (GuiaPath guiaExtPath in classGuiaSolicProc.GuiaPaths)
                {
                    if (guiaExtPath.IsExtensao)
                    {
                        docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao gExtSolicProrrogacao =
                            new TISS_Add_in.docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao();
                        gExtSolicProrrogacao = (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao)geraGuiaSolicitacaoProcedimento(guiaExtPath.FilePath, "guiaSolicitacaoProrrogacao", "guiaSolicitacaoProrrogacao", classGuiaSolicProc.TipoSolicitacao);

                        if (gExtSolicProrrogacao.procedimentosExamesSolicitados != null)
                        {
                            foreach (object solicProcExt in gExtSolicProrrogacao.procedimentosExamesSolicitados)
                            {
                                Procedimento procedimento = new Procedimento(solicProcExt, guiaExtPath.Indice, false,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)solicProcExt).procedimento);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        if (gExtSolicProrrogacao.OPMsSolicitadas != null)
                        {
                            foreach (object solicOPMExt in gExtSolicProrrogacao.OPMsSolicitadas)
                            {
                                Procedimento procedimento = new Procedimento(solicOPMExt, guiaExtPath.Indice, true,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)solicOPMExt).OPM);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                    }
                }
                gSolicProrrogacao.procedimentosExamesSolicitados = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado[classGuiaSolicProc.CountProcedimentos];
                gSolicProrrogacao.procedimentosExamesSolicitados = classGuiaSolicProc.ProcedimentoToArray().ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado>(objToProcedimento)).ToArray();
                gSolicProrrogacao.OPMsSolicitadas = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada[classGuiaSolicProc.CountOPMs];
                gSolicProrrogacao.OPMsSolicitadas = classGuiaSolicProc.OPMToArray().ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada>(objToOPM)).ToArray();
                classGuiaSolicProc.GuiaSolicProc = gSolicProrrogacao;
                return gSolicProrrogacao;
            }
            return null;
        }

        public static docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT geraEnviaGuiaSP_SADT(ref GuiaSolicitacaoProcedimento classGuiaSolicProc)
        {
            if (classGuiaSolicProc.CountGuias > 0)
            {
                docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT gSolicSP_SADT =
                        new TISS_Add_in.docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT();

                foreach (GuiaPath guiaPrincipalPath in classGuiaSolicProc.GuiaPaths)
                {
                    if (!guiaPrincipalPath.IsExtensao)
                    {
                        gSolicSP_SADT = (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT)geraGuiaSolicitacaoProcedimento(guiaPrincipalPath.FilePath, "guiaSolicitacaoSADT", "guiaSolicitacaoSADT", classGuiaSolicProc.TipoSolicitacao);
                        if (gSolicSP_SADT.procedimentosSolicitados != null)
                        {
                            foreach (object solicProc in gSolicSP_SADT.procedimentosSolicitados)
                            {
                                Procedimento procedimento = new Procedimento(solicProc, guiaPrincipalPath.Indice, false,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)solicProc).procedimento);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        if (gSolicSP_SADT.opmSolicitada != null)
                        {
                            foreach (object solicOPM in gSolicSP_SADT.opmSolicitada)
                            {
                                Procedimento procedimento = new Procedimento(solicOPM, guiaPrincipalPath.Indice, true,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)solicOPM).OPM);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        break;
                    }
                }

                foreach (GuiaPath guiaExtPath in classGuiaSolicProc.GuiaPaths)
                {
                    if (guiaExtPath.IsExtensao)
                    {
                        docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT gExtSolicSP_SADT =
                            new TISS_Add_in.docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT();
                        gExtSolicSP_SADT = (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT)geraGuiaSolicitacaoProcedimento(guiaExtPath.FilePath, "guiaSolicitacaoSADT", "guiaSolicitacaoSADT", classGuiaSolicProc.TipoSolicitacao);

                        if (gExtSolicSP_SADT.procedimentosSolicitados != null)
                        {
                            foreach (object solicProcExt in gExtSolicSP_SADT.procedimentosSolicitados)
                            {
                                Procedimento procedimento = new Procedimento(solicProcExt, guiaExtPath.Indice, false,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado)solicProcExt).procedimento);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                        if (gExtSolicSP_SADT.opmSolicitada != null)
                        {
                            foreach (object solicOPMExt in gExtSolicSP_SADT.opmSolicitada)
                            {
                                Procedimento procedimento = new Procedimento(solicOPMExt, guiaExtPath.Indice, true,
                                    ((docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada)solicOPMExt).OPM);
                                classGuiaSolicProc.insereProcedimento(procedimento);
                            }
                        }
                    }
                }
                gSolicSP_SADT.procedimentosSolicitados = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado[classGuiaSolicProc.CountProcedimentos];
                gSolicSP_SADT.procedimentosSolicitados = classGuiaSolicProc.ProcedimentoToArray().ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado>(objToProcedimento)).ToArray();
                gSolicSP_SADT.opmSolicitada = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada[classGuiaSolicProc.CountOPMs];
                gSolicSP_SADT.opmSolicitada = classGuiaSolicProc.OPMToArray().ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada>(objToOPM)).ToArray();
                classGuiaSolicProc.GuiaSolicProc = gSolicSP_SADT;
                return gSolicSP_SADT;
            }
            return null;
        }

        /// <summary>
        /// Preenche a Solicitação de Procedimentos
        /// </summary>
        /// <param name="guiaSolicitacaoProcedimento">objeto da Guia Solicitação de Procedimento</param>
        /// <returns>Solicitação de Procedimentos preenchida</returns>
        public static docTissSolicitacaoProcedimento.ws_solicitacaoProcedimento geraSolicitacaoProcedimento(
            ref GuiaSolicitacaoProcedimento guiaSolicitacaoProcedimento, bool geraXML)
        {
            docTissSolicitacaoProcedimento.ws_solicitacaoProcedimento enviaSolicitacao =
                new TISS_Add_in.docTissSolicitacaoProcedimento.ws_solicitacaoProcedimento();

            if (!geraXML)
                enviaSolicitacao.cabecalho = (docTissSolicitacaoProcedimento.cabecalhoTransacao)Cabecalho.GeraCabecalho(
                    guiaSolicitacaoProcedimento.CodPrestador, guiaSolicitacaoProcedimento.RegANS, tipoTransacao.SOLICITACAO_PROCEDIMENTOS);
            else
                enviaSolicitacao.cabecalho = (docTissSolicitacaoProcedimento.cabecalhoTransacao)Cabecalho.GeraCabecalho(
                    guiaSolicitacaoProcedimento.CodPrestador, guiaSolicitacaoProcedimento.RegANS, tipoTransacao.GERA_XML_SOLICITACAO_PROCEDIMENTOS);

            if (enviaSolicitacao.cabecalho != null)
            {
                try
                {
                    enviaSolicitacao.solicitacaoProcedimento = new TISS_Add_in.docTissSolicitacaoProcedimento.ws_solicitacaoProcedimentoSolicitacaoProcedimento();
                    enviaSolicitacao.solicitacaoProcedimento.Items = new object[1];
                    switch (guiaSolicitacaoProcedimento.TipoSolicitacao)
                    {
                        case TipoGuia.Solicitação_Internação:
                            enviaSolicitacao.solicitacaoProcedimento.Items[0] = geraEnviaGuiaSolicInternacao(ref guiaSolicitacaoProcedimento);
                            break;
                        case TipoGuia.Solicitação_Prorrogação:
                            enviaSolicitacao.solicitacaoProcedimento.Items[0] = geraEnviaGuiaProrrogacao(ref guiaSolicitacaoProcedimento);
                            break;
                        case TipoGuia.Solicitação_SADT:
                            enviaSolicitacao.solicitacaoProcedimento.Items[0] = geraEnviaGuiaSP_SADT(ref guiaSolicitacaoProcedimento);
                            break;
                        //TODO: OV Envia Guia Solicitacao Odonto
                        /*case TipoGuia.Solicitação_Odontologia:
                            enviaSolicitacao.solicitacaoProcedimento.Items[0] = geraGuiaSolicOdonto(guiaPath, guiaExtPaths);
                            break;
                        default:
                            break;*/
                    }
                    //Fechando a Solicitação de Procedimento e Serializando em Memória
                    Stream streamMensagem = new MemoryStream();
                    streamMensagem = XMLUtils.Serializa(enviaSolicitacao, null);

                    //Fim da Mensagem: HASH
                    //Lendo a mensagem previamene carregada em memória
                    XmlDocument docMensagem = new XmlDocument();
                    docMensagem.Load(streamMensagem);
                    string TextoHash = "";
                    TextoHash = docMensagem.DocumentElement.InnerText;

                    //Calculando e inserindo o Hash da Mensagem
                    enviaSolicitacao.hash = AddinUtils.CalculateMD5Hash(TextoHash);

                    return enviaSolicitacao;
                }
                catch (Exception exx)
                {
                    MessageBox.Show("Erro ao gerar a Solicitação de Procedimento: " + exx.Message + "\n" + exx.InnerException.Message, "Guia não enviada!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                    Mensagem.mensagemTISS_remove(Convert.ToInt64(enviaSolicitacao.cabecalho.identificacaoTransacao.sequencialTransacao));
                    return null;
                }
            }
            return null;
        }

        /// <summary>
        /// Trata a mensagem de resposta da Solicitação de Procedimento
        /// </summary>
        /// <param name="recibo">Objeto de resposta da Solicitação de Procedimento</param>
        public static void recebeSolicitacaoProcedimento(docTissSolicitacaoProcedimento.ws_autorizacaoProcedimento recibo, GuiaSolicitacaoProcedimento classGuiaSolicProc)
        {
            foreach (docTissSolicitacaoProcedimento.ws_autorizacaoProcedimentoAutorizacaoServico autorizacaoServico in recibo.autorizacaoServico)
            {
                string numeroGuia = autorizacaoServico.identificacaoAutorizacao.numeroGuiaPrestador;
                statusRecebimento statusSolicitacao;
                //Procura a Classe de guiaSolicProc no Array que tenha o mesmo número de Guia
                if (numeroGuia == classGuiaSolicProc.NumeroGuia)
                {
                    if (autorizacaoServico.statusSolicitacao == TISS_Add_in.docTissSolicitacaoProcedimento.st_statusSolicitacao.Item1)
                        statusSolicitacao = statusRecebimento.Autorizado;
                    else if (autorizacaoServico.statusSolicitacao == TISS_Add_in.docTissSolicitacaoProcedimento.st_statusSolicitacao.Item2)
                        statusSolicitacao = statusRecebimento.Em_analise;
                    else
                        statusSolicitacao = statusRecebimento.Negado;
                    CommandSolicitacao.updateStatusRecebimentoSolicProc(classGuiaSolicProc.RegANS, classGuiaSolicProc.CodPrestador, numeroGuia, (DBConnect.statusRecebimento)statusSolicitacao);
                    string templatePath = "";
                    switch (classGuiaSolicProc.TipoSolicitacao)
                    {
                        case TipoGuia.Solicitação_Internação:
                            templatePath = AppDomain.CurrentDomain.BaseDirectory + "templates\\guiaSolicitacaoInternacaoResposta.docx";
                            break;
                        case TipoGuia.Solicitação_Prorrogação:
                            templatePath = AppDomain.CurrentDomain.BaseDirectory + "templates\\guiaSolicitacaoProrrogacaoResposta.docx";
                            break;
                        case TipoGuia.Solicitação_SADT:
                            templatePath = AppDomain.CurrentDomain.BaseDirectory + "templates\\guiaSolicitacaoSP_SADTResposta.docx";
                            break;
                        case TipoGuia.Solicitação_Odontologia:
                            templatePath = AppDomain.CurrentDomain.BaseDirectory + "templates\\guiaSolicitacaoOdontoResposta.docx";
                            break;
                    }
                    if (templatePath != "")
                    {
                        foreach (GuiaPath guiaPath in classGuiaSolicProc.GuiaPaths)
                        {
                            File.Copy(templatePath, guiaPath.FilePath, true);
                            XmlSerializer xs;
                            XmlSerializer xsAutorizacao;
                            Stream stream = new MemoryStream();
                            XmlDocument xdoc = new XmlDocument();
                            XmlDocument xdocAutorizacao = new XmlDocument();
                            switch (classGuiaSolicProc.TipoSolicitacao)
                            {
                                case TipoGuia.Solicitação_Internação:
                                    docTissSolicitacaoProcedimento.ct_guiaSolicInternacao guiaSolicInternacao =
                                        (docTissSolicitacaoProcedimento.ct_guiaSolicInternacao)classGuiaSolicProc.GuiaSolicProc;
                                    guiaSolicInternacao.procedimentosExamesSolicitados = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado[classGuiaSolicProc.CountProcedimentosOfGuia(guiaPath.Indice)];
                                    guiaSolicInternacao.OPMsSolicitadas = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada[classGuiaSolicProc.CountOPMsOfGuia(guiaPath.Indice)];
                                    guiaSolicInternacao.procedimentosExamesSolicitados = classGuiaSolicProc.ProcedimentoToArrayOfGuia(guiaPath.Indice).ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado>(objToProcedimento)).ToArray();
                                    guiaSolicInternacao.OPMsSolicitadas = classGuiaSolicProc.OPMToArrayOfGuia(guiaPath.Indice).ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada>(objToOPM)).ToArray();

                                    stream = XMLUtils.Serializa(guiaSolicInternacao, XMLUtils.ElementRootWithANSnamespace("guiaSolicInternacao"));
                                    xdoc.Load(stream);
                                    XMLUtils.SubstituiCustomXmlPart(guiaPath.FilePath, "guiaSolicInternacao", xdoc);

                                    stream = new MemoryStream();
                                    xsAutorizacao = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ws_autorizacaoProcedimentoAutorizacaoServico), XMLUtils.ElementRootWithANSnamespace("dadosAutorizacao"));
                                    xsAutorizacao.Serialize(stream, autorizacaoServico, XMLUtils.ANSnamespace());
                                    stream.Position = 0;
                                    xdocAutorizacao.Load(stream);
                                    XMLUtils.SubstituiCustomXmlPart(guiaPath.FilePath, "dadosAutorizacao", xdocAutorizacao);
                                    break;


                                case TipoGuia.Solicitação_Prorrogação:
                                    docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao guiaSolicProrrogacao =
                                        (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao)classGuiaSolicProc.GuiaSolicProc;
                                    guiaSolicProrrogacao.procedimentosExamesSolicitados = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado[classGuiaSolicProc.CountProcedimentosOfGuia(guiaPath.Indice)];
                                    guiaSolicProrrogacao.OPMsSolicitadas = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada[classGuiaSolicProc.CountOPMsOfGuia(guiaPath.Indice)];
                                    guiaSolicProrrogacao.procedimentosExamesSolicitados = classGuiaSolicProc.ProcedimentoToArrayOfGuia(guiaPath.Indice).ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado>(objToProcedimento)).ToArray();
                                    guiaSolicProrrogacao.OPMsSolicitadas = classGuiaSolicProc.OPMToArrayOfGuia(guiaPath.Indice).ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada>(objToOPM)).ToArray();

                                    xs = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ct_guiaSolicitacaoProrrogacao), XMLUtils.ElementRootWithANSnamespace("guiaSolicitacaoProrrogacao"));
                                    xs.Serialize(stream, guiaSolicProrrogacao, XMLUtils.ANSnamespace());
                                    stream.Position = 0;
                                    xdoc.Load(stream);
                                    XMLUtils.SubstituiCustomXmlPart(guiaPath.FilePath, "guiaSolicitacaoProrrogacao", xdoc);

                                    stream = new MemoryStream();
                                    xsAutorizacao = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ws_autorizacaoProcedimentoAutorizacaoServico), XMLUtils.ElementRootWithANSnamespace("dadosAutorizacao"));
                                    xsAutorizacao.Serialize(stream, autorizacaoServico, XMLUtils.ANSnamespace());
                                    stream.Position = 0;
                                    xdocAutorizacao.Load(stream);
                                    XMLUtils.SubstituiCustomXmlPart(guiaPath.FilePath, "dadosAutorizacao", xdocAutorizacao);
                                    break;


                                case TipoGuia.Solicitação_SADT:
                                    docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT guiaSolicSP_SADT =
                                        (docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT)classGuiaSolicProc.GuiaSolicProc;
                                    guiaSolicSP_SADT.procedimentosSolicitados = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado[classGuiaSolicProc.CountProcedimentosOfGuia(guiaPath.Indice)];
                                    guiaSolicSP_SADT.opmSolicitada = new TISS_Add_in.docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada[classGuiaSolicProc.CountOPMsOfGuia(guiaPath.Indice)];
                                    guiaSolicSP_SADT.procedimentosSolicitados = classGuiaSolicProc.ProcedimentoToArrayOfGuia(guiaPath.Indice).ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_procedimentosSolicitadosProcedimentoSolicitadoProcedimentoSolicitado>(objToProcedimento)).ToArray();
                                    guiaSolicSP_SADT.opmSolicitada = classGuiaSolicProc.OPMToArrayOfGuia(guiaPath.Indice).ConvertAll(new Converter<object, docTissSolicitacaoProcedimento.ArrayOfCt_OPMSolicitadasOPMSolicitadaOPMSolicitada>(objToOPM)).ToArray();

                                    xs = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ct_guiaSolicitacaoSP_SADT), XMLUtils.ElementRootWithANSnamespace("guiaSolicitacaoSADT"));
                                    xs.Serialize(stream, guiaSolicSP_SADT, XMLUtils.ANSnamespace());
                                    stream.Position = 0;
                                    xdoc.Load(stream);
                                    XMLUtils.SubstituiCustomXmlPart(guiaPath.FilePath, "guiaSolicitacaoSADT", xdoc);

                                    stream = new MemoryStream();
                                    xsAutorizacao = new XmlSerializer(typeof(docTissSolicitacaoProcedimento.ws_autorizacaoProcedimentoAutorizacaoServico), XMLUtils.ElementRootWithANSnamespace("dadosAutorizacao"));
                                    xsAutorizacao.Serialize(stream, autorizacaoServico, XMLUtils.ANSnamespace());
                                    stream.Position = 0;
                                    xdocAutorizacao.Load(stream);
                                    XMLUtils.SubstituiCustomXmlPart(guiaPath.FilePath, "dadosAutorizacao", xdocAutorizacao);
                                    break;


                                case TipoGuia.Solicitação_Odontologia:

                                    break;
                            }
                        }
                    }
                }
            }
        }

    }
}
